﻿// Autore: Mattia Barrasso

using System.Linq;
using NUnit.Framework;
using RecipesManager.Data;
using TechTalk.SpecFlow;
using White.Core.UIItems;
using White.Core.UIItems.Finders;
using White.Core.UIItems.ListBoxItems;
using White.Core.UIItems.WPFUIItems;

namespace RecipesManager.Specs.Ospite
{
    [Binding, Scope(Feature = "ModificaOspite")]
    class ModificaOspite_Steps : OspiteBdd
    {
        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        public new void TearDownScenario()
        {
            base.TearDownScenario();
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" esiste")]
        public void DatoEsisteOspite(string ospite)
        {
            Manager.Guests.Add(ospite);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" non esiste")]
        public void DatoNonEsisteOspite(string ospite)
        {
            Assert.That(!Manager.Guests.Contains(ospite));
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una relazione con \"([a-zA-Z ]+)\"")]
        public void DataRelazioneFraOspiti(string ospite, string ospiteInRelazione)
        {
            Manager.Guests[ospite].GuestRelationships.Add(ospiteInRelazione);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" è intollerante all'ingrediente \"([a-zA-Z ]+)\"")]
        public void DataIntolleranzaVersoIngrediente(string ospite, string ingrediente)
        {
            Manager.Guests[ospite].IngredientIntolerances.Add(ingrediente);
        }

        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" esiste")]
        public void DatoIngredienteEsistente(string ingrediente)
        {
            Manager.Ingredients.Add(ingrediente, MeasureType.Weight);
        }

        [Given(Regex = "seleziono l'ospite \"([a-zA-Z ]+)\"")]
        public void DatoOspiteSelezionato(string ospite)
        {
            if(!MainWindow.Title.Equals(ShopManagerTitle)){
                NavigateToGuests();
                GetGuestsUi();
            }
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Guests.Select(ospite);
            GetSingleGuestUi();
        }

        [Given(Regex = "ho inserito i valori")]
        public void DatoInseritoValori(Table table)
        {
            foreach (var tableRow in table.Rows)
            {
                if(tableRow["Attributi"].Equals("Nome"))
                {
                    GuestName.SetValue(tableRow["Valori"]);
                }else if(tableRow["Attributi"].Equals("Nota"))
                {
                    GuestNote.SetValue(tableRow["Valori"]);
                }else
                {
                    Assert.Fail("Table");
                }
            }
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una preferenza per l'ospite \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void DataPreferenzaEsistente(string ospite, string ospitePreferito, int valore)
        {
            var guestRating = GuestRating.VeryGood;
            if(valore == 2)
            {
                guestRating = GuestRating.VeryGood;
            }else
            {
                Assert.Fail();
            }
            Manager.Guests[ospite].GuestRatings.Add(ospitePreferito, guestRating);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una preferenza per l'ingrediente \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void DataPreferenzaCibo(string ospite, string cibo, int valore)
        {
            var foodRating = FoodRating.VeryGood;
            if(valore == 2)
            {
                foodRating = FoodRating.VeryGood;
            }else
            {
                Assert.Fail();
            }
            Manager.Guests[ospite].IngredientRatings.Add(cibo, foodRating);
        }

        [When(Regex = "salvo")]
        public void QuandoSalvo()
        {
            Assert.That(Save.Enabled);
            Save.Click();
        }

        [When(Regex = "visiono le potenziali preferenze verso gli ospiti")]
        public void QuandoVisionoPotenzialiOspiti()
        {
            GuestsPreferences.Click();
        }

        [When(Regex = "visiono le potenziali preferenze verso i cibi")]
        public void QuandoVisionoPotenzialiCibi()
        {
            FoodPreferences.Click();
        }

        [When(Regex = "rimuovo la relazione con \"([a-zA-Z ]+)\"")]
        public void QuandoRimuovoRelazione(string ospite)
        {
            SelezionaPersonaPreferita(ospite);
            RemoveGuestPreference.Click();
        }

        [When(Regex = "modifico la preferenza per l'ingrediente \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void QuandoModificoPreferenzaCIbo(string cibo, int valore)
        {
            var index = 0;
            if(valore == 2)
            {
                index = 0;
            }else if(valore == 1)
            {
                index = 1;
            }else
            {
                Assert.Fail();
            }
            base.ModificaPreferenzaCibo(cibo, index);
        }

        [When(Regex = "modifico la preferenza per l'ospite \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void QuandoModificoPreferenzaOspite(string ospite, int valore)
        {
            var index = 0;
            if (valore == 2)
            {
                index = 0;
            }
            else if (valore == 1)
            {
                index = 1;
            }
            else
            {
                Assert.Fail();
            }
            base.ModificaPreferenzaPersona(ospite, index);
        }

        [Then(Regex = "l'ingrediente \"([a-zA-Z ]+)\" non è presente")]
        public void AlloraCiboNonPresente(string cibo)
        {
            Assert.That(!FoodPreferences.Items.Exists(item => item.Text.Equals(cibo)));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" non è presente")]
        public void OspiteNonSelezionabile(string ospite)
        {
            Assert.That(!GuestsPreferences.Items.Exists(item => item.Text.Equals(ospite)));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" è presente")]
        public void OspiteSelezionabile(string ospite)
        {
            Assert.That(GuestsPreferences.Items.Exists(item => item.Text.Equals(ospite)));
        }

        [Then(Regex = "non esiste una relazione con \"([a-zA-Z ]+)\"")]
        public void OspiteNonInRelazione(string ospite)
        {
            var i = CercaPersonaPreferita(ospite);
            var lw = (ListView)SelectedGuestsPreferences;
            var checkBox = lw.Rows[i].Get<CheckBox>(SearchCriteria.All);
            Assert.That(!checkBox.Checked);
        }

        [Then(Regex = "l'operazione ha successo")]
        public void AlloraSuccesso()
        {
            Assert.That(!MainWindow.ModalWindows().Any());
        }

        [Then(Regex = "l'operazione non ha successo")]
        public void AlloraInsuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count == 1);
        }

        [Then(Regex = "esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraEsisteOspite(string ospite)
        {
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Manager.ClearCache();
            Assert.That(Manager.Guests.Contains(ospite));
        }

        [Then(Regex = "non esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraNonEsisteOspite(string ospite)
        {
            Assert.That(!Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Assert.That(!Manager.Guests.Contains(ospite));
        }

        [Then(Regex = "esiste la preferenza per l'ingrediente \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void AlloraEsistePreferenzaIngrediente(string cibo, int valore)
        {
            var i = CercaCiboPreferito(cibo);
            var lw = (ListView)SelectedFoodPreferences;
            var comboBox = lw.Rows[i].Get<ComboBox>(SearchCriteria.All);
            var text = "Gradito";
            if (valore == 1)
            {
                text = "Gradito";
            }
            else
            {
                Assert.Fail();
            }
            Assert.That(comboBox.SelectedItem.Text.Equals(text));
        }

        [Then(Regex = "esiste la preferenza per l'ospite \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void AlloraEsistePreferenzaOspite(string persona, int valore)
        {
            var i = CercaPersonaPreferita(persona);
            var lw = (ListView)SelectedGuestsPreferences;
            var comboBox = lw.Rows[i].Get<ComboBox>(SearchCriteria.All);
            var text = "Gradito";
            if(valore == 1)
            {
                text = "Gradito";
            }else
            {
                Assert.Fail();
            }
            Assert.That(comboBox.SelectedItem.Text.Equals(text));
        }
    }
}
